// 如何用字符串的方式存储每一个星群，并建立对应的映射
// 如何判断相似?
// 两个星阵相似，说明星阵形状完全一样，所以点内的相对距离一定是一样的
// 所以可以通过存储点内的相对距离来进行判断相似
#include <iostream>
#include <unordered_map>
#include <algorithm>
#include <vector>
#include <cstring>
#include <cmath>
// #include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> PII;

const int N = 110;
char g[N][N];
// vector<PII> v; // 用来存储每次dfs所保存的星星路径
int h, w;
int dx[8] = { 0, 0, 1, -1, 1, -1, -1, 1 }, dy[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };
unordered_map<double, char> hsh;
double eps = 1e-7;

void dfs(int x, int y, vector<PII>& v)
{
    v.push_back({x, y});
    g[x][y] = '0';
    for(int i = 0; i < 8; ++i)
    {
        int xx = x + dx[i], yy = y + dy[i];
        if(xx > 0 && xx <= h && yy > 0 && yy <= w && g[xx][yy] == '1')
            dfs(xx, yy, v);
    }
}

double get_dist(const PII& a, const PII& b)
{
    double dx = abs(a.first - b.first), dy = abs(a.second - b.second);
    return sqrt(dx * dx + dy * dy);
}

char get_hash(const vector<PII>& v)
{
    size_t sz = v.size();
    double sum = 0;
    // 通过点内距离来定义一个星星
    for(size_t i = 0; i < sz; ++i)
        for(size_t j = i + 1; j < sz; ++j)
            sum += get_dist(v[i], v[j]);
    // cout << sum << ' ';
    for(const auto& [x, ch]: hsh)
        if(fabs(x - sum) < eps) // 说明相似的星星前面已经出现过了
            return ch;
    // 到这里说明前面没有出现过，插入新的星星
    // cout << "!!!";
    size_t num = hsh.size();
    hsh[sum] = 'a' + num;
    return hsh[sum];
    
}

void fill(const char id, const vector<PII>& v)
{
    for(const auto [x, y]: v)
        g[x][y] = id;
}

int main()
{
    cin >> w >> h;
    for(int i = 1; i <= h; ++i) cin >> (g[i] + 1);
    for(int i = 1; i <= h; ++i)
        for(int j = 1; j <= w; ++j)
            if(g[i][j] == '1') // 如果是星星并且还没有遍历，进行处理
            {
                vector<PII> v;
                // cout << i << ' ' << j << "...";
                dfs(i, j, v); // 找到和当前星星相连的所有星星
                char id = get_hash(v);
                // cout << id << endl;
                fill(id, v);
            }
    for(int i = 1; i <= h; ++i)
        cout << (g[i] + 1) << endl;
    
    return 0;
}
